On proving the correctness of data type implementations

Journal ArticleIn order to prove the correctness (or consistency) of an implementation of a data type with respect to the data type's specifications, the minimal amount of information that needs to be provided consists of: (i) a specification of the type being implemented; (ii) a specification of the representation type; and (iii) a specification of an implementation. This paper develops a method for proving the correctness of data type implementations that requires only this minimal amount of information to be specified in order for a proof to be attempted; this is in contrast to several of the existing methods which need additional information augmenting (i)-(iii) to be specified in order to be applicable. The ensuing generality of the proposed method makes it more amenable to automation. Examples of applications of the proof method are presented, all of which have been automated

A new approach to specifying and handling exceptions

technical reportAn operation generally exhibits different patterns of behavior over different parts of its domain. Depending upon the context, such behavior may either be conceived of as "normal" or as an "exception." Thus, the behavior of an operation Is quite naturally characterized by the set of partial operations that characterize its (different) behavior on Its subdomains, and exceptions essentially serve to extend (modify) the normal behavior of an operation. In this milieu, we consider the issues of specifying and "handling" exceptional conditions that might occur during the execution of an operation. We argue that one of the important features that an exception handling mechanism need possess is to enable the behavior of an operation be altered over part of Its domain i.e. that of being able o incrementally modify t h e semantics of t h e partial operations that serve to characterize an operation. Surprisingly, this requirement arises out of a pragmatic consideration ? that of providing for the existence of a library of subroutines. We propose a general mechanism for specifying exceptions and their handlers that does not compromise the possibility of efficient implementations. Examples of application of the method are presented In the context of abstract algebraic) data type specifications, using skeletal specifications of a Stack and an error-correcting parser for a context free grammar. The major advantage of the proposed mechanism over conventional appoaches is that of completely avoiding the problem of "dynamic context propagation.

Modeling of call - by - need and stream primitives using CCS

technical reportThe semantics of an applicative language are presented using the algebraic primitives introduced in CCS. In particular, the language constructs modeled allow for nondeterminism, stream processing and demand driven (call by need) evaluation

An algebraic formulation of seitz's weak conditions for self timed circuits

technical reportTwo fairly intuitive conditions are given that serve to algebraically characterize Seitz's "weak conditions" for self timed circuits. It is shown that these two conditions embody the 12 temporal logic conditions (developed b y Owicki and Malachi) which are intended to express both the weak conditions as well as certain liveness properties that self timed circuits need to satisfy

TRACIS: transformations on Ada for circuit synthesis a report on the methodology for a silicon compiler

technical reportThis report describes in detail, the ongoing design and implementation of a transformation system, for compiling specifications of integrated circuits into silicon. There are many levels in this process, and the area that we focus on produces target specifications of asynchronous and synchronous control units and the associated data paths. This target is compatible with the ASSASSIN system [1] which generates layouts from specifications of control units. The input to our system is an Ada program (restricted to a single Procedure Body) which specifies a certain computation. The Procedure Body is itself assumed to contain no package or task declarations or inatantiations and no Entry call statements. The result of the transformations performed by the system is a program consisting of the original specifications, with the target description appended to it

Boolean Operations on n- Dimensional Objects

Computation of the union, intersection, and difference of n- dimensional objects plays a central role in several computer- aided geometric design problems. An algorithm for computing these operations that uses a boundary classification technique is presented here. The algorithm is recursive in structure, with the recursion being on the dimensions of objects dealt with at each stage. The representation treats all entities as objects, making no distinction between faces, edges or vertices. The objects produced are'regularized,'that is, there are no degenerate boundaries such as dangling edges. The sample application given involved hidden-surface remova

FUNLOG = functions + logic: a computational model integrating logic programming and functional programming (Rev. May 1983)

technical reportFunlog, a computational model which attempts to integrate functional programming and logic programming is described. The model supports computations with infinite data structures without the introduction of complex control issues at the user-level. Control characteristics are improved as compared with pure logic programming languages. A novel lazy reduction mechanism, pattern?driven reduction, for the underlying functional model is developed which cleanly and naturally achieves reduction?by-need. An abstract semantic unification algorithm is given upon which the resolution is based. Several example programs in Funlog are presented, including a program for finding the first N "lucky numbers". Programming in Funlog offers the flexibility of choosing between a backtracking free (determinate or indeterminate) computational framework and a non-deterministic one. Some implementation issues are also discussed